home *** CD-ROM | disk | FTP | other *** search
/ PC World 2007 September / PCWorld_2007-09_cd.bin / system / ntfs / ntfsundelete.exe / {app} / copy_reg.pyc (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2007-02-05  |  4.7 KB  |  168 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.4)
  3.  
  4. '''Helper to provide extensibility for pickle/cPickle.
  5.  
  6. This is only useful to add pickle support for extension types defined in
  7. C, not for instances of user-defined classes.
  8. '''
  9. from types import ClassType as _ClassType
  10. __all__ = [
  11.     'pickle',
  12.     'constructor',
  13.     'add_extension',
  14.     'remove_extension',
  15.     'clear_extension_cache']
  16. dispatch_table = { }
  17.  
  18. def pickle(ob_type, pickle_function, constructor_ob = None):
  19.     if type(ob_type) is _ClassType:
  20.         raise TypeError('copy_reg is not intended for use with classes')
  21.     
  22.     if not callable(pickle_function):
  23.         raise TypeError('reduction functions must be callable')
  24.     
  25.     dispatch_table[ob_type] = pickle_function
  26.     if constructor_ob is not None:
  27.         constructor(constructor_ob)
  28.     
  29.  
  30.  
  31. def constructor(object):
  32.     if not callable(object):
  33.         raise TypeError('constructors must be callable')
  34.     
  35.  
  36.  
  37. try:
  38.     complex
  39. except NameError:
  40.     pass
  41.  
  42.  
  43. def pickle_complex(c):
  44.     return (complex, (c.real, c.imag))
  45.  
  46. pickle(complex, pickle_complex, complex)
  47.  
  48. def _reconstructor(cls, base, state):
  49.     if base is object:
  50.         obj = object.__new__(cls)
  51.     else:
  52.         obj = base.__new__(cls, state)
  53.         base.__init__(obj, state)
  54.     return obj
  55.  
  56. _HEAPTYPE = 1 << 9
  57.  
  58. def _reduce_ex(self, proto):
  59.     if not proto < 2:
  60.         raise AssertionError
  61.     for base in self.__class__.__mro__:
  62.         if hasattr(base, '__flags__') and not (base.__flags__ & _HEAPTYPE):
  63.             break
  64.             continue
  65.     else:
  66.         base = object
  67.     if base is object:
  68.         state = None
  69.     elif base is self.__class__:
  70.         raise TypeError, "can't pickle %s objects" % base.__name__
  71.     
  72.     state = base(self)
  73.     args = (self.__class__, base, state)
  74.     
  75.     try:
  76.         getstate = self.__getstate__
  77.     except AttributeError:
  78.         if getattr(self, '__slots__', None):
  79.             raise TypeError('a class that defines __slots__ without defining __getstate__ cannot be pickled')
  80.         
  81.         
  82.         try:
  83.             dict = self.__dict__
  84.         except AttributeError:
  85.             dict = None
  86.         except:
  87.             None<EXCEPTION MATCH>AttributeError
  88.         
  89.  
  90.         None<EXCEPTION MATCH>AttributeError
  91.  
  92.     dict = getstate()
  93.     if dict:
  94.         return (_reconstructor, args, dict)
  95.     else:
  96.         return (_reconstructor, args)
  97.  
  98.  
  99. def __newobj__(cls, *args):
  100.     return cls.__new__(cls, *args)
  101.  
  102.  
  103. def _slotnames(cls):
  104.     """Return a list of slot names for a given class.
  105.  
  106.     This needs to find slots defined by the class and its bases, so we
  107.     can't simply return the __slots__ attribute.  We must walk down
  108.     the Method Resolution Order and concatenate the __slots__ of each
  109.     class found there.  (This assumes classes don't modify their
  110.     __slots__ attribute to misrepresent their slots after the class is
  111.     defined.)
  112.     """
  113.     names = cls.__dict__.get('__slotnames__')
  114.     if names is not None:
  115.         return names
  116.     
  117.     names = []
  118.     
  119.     try:
  120.         cls.__slotnames__ = names
  121.     except:
  122.         None if not hasattr(cls, '__slots__') else names
  123.  
  124.     return names
  125.  
  126. _extension_registry = { }
  127. _inverted_registry = { }
  128. _extension_cache = { }
  129.  
  130. def add_extension(module, name, code):
  131.     '''Register an extension code.'''
  132.     code = int(code)
  133.     if code <= code:
  134.         pass
  135.     elif not code <= 2147483647:
  136.         raise ValueError, 'code out of range'
  137.     
  138.     key = (module, name)
  139.     if _extension_registry.get(key) == code and _inverted_registry.get(code) == key:
  140.         return None
  141.     
  142.     if key in _extension_registry:
  143.         raise ValueError('key %s is already registered with code %s' % (key, _extension_registry[key]))
  144.     
  145.     if code in _inverted_registry:
  146.         raise ValueError('code %s is already in use for key %s' % (code, _inverted_registry[code]))
  147.     
  148.     _extension_registry[key] = code
  149.     _inverted_registry[code] = key
  150.  
  151.  
  152. def remove_extension(module, name, code):
  153.     '''Unregister an extension code.  For testing only.'''
  154.     key = (module, name)
  155.     if _extension_registry.get(key) != code or _inverted_registry.get(code) != key:
  156.         raise ValueError('key %s is not registered with code %s' % (key, code))
  157.     
  158.     del _extension_registry[key]
  159.     del _inverted_registry[code]
  160.     if code in _extension_cache:
  161.         del _extension_cache[code]
  162.     
  163.  
  164.  
  165. def clear_extension_cache():
  166.     _extension_cache.clear()
  167.  
  168.